#include "AffichageSDL.h"
#include <time.h>
#include <assert.h>


/**
 @brief void SDL_appliquer_surface( SDL_Surface* source, SDL_Surface* destination, int x, int y );
**/

<<<<<<< .mine
=======
/*Preconditions : nomFic nom d'fichier BMP existant
 *Postcondition : retourne un SDL_Surface avec l'image optimisee*/

>>>>>>> .r52
void sdljeuInit(sdlJeu *pSdlJeu)
{
    int dimXFenetre, dimYFenetre;
    Jeu *j;

<<<<<<< .mine
   /**
    @brief j est le pointeur sur la structure "jeu" de AffichageSDL
    **/
=======
    /* j est le pointeur sur la structure "jeu" de AffichageSDL */
>>>>>>> .r52
    j=&(pSdlJeu->jeu);

<<<<<<< .mine

    /**
     @brief Initialisation du jeu
     **/
=======
    /* Initialisation du jeu */
>>>>>>> .r52
    initJeu(j);
    parametreJeu(j);

    /**
      @brief On donne la taille de la fenetre
    **/
    dimXFenetre=getdimXTerrain(&(j->terrain));
    dimYFenetre=getdimYTerrain(&(j->terrain));

    /* Initialisation de SDL et SDL_ttf */
    assert(SDL_Init( SDL_INIT_VIDEO )!= -1 );

   // SDL_INIT_EVERYTHING
    assert (TTF_Init()!=-1);

    /**
      @brief Initialisation de surfaceEcran
    **/
    pSdlJeu->surfaceEcran = SDL_SetVideoMode(dimXFenetre, dimYFenetre, 32, SDL_HWSURFACE );  // Ecran de 800*600 pixels

    assert( pSdlJeu->surfaceEcran!=NULL);

    SDL_WM_SetCaption( "Space Pursuit", NULL );

    /* Initialisation des polices */
    pSdlJeu->police = NULL;
    pSdlJeu->police = TTF_OpenFont("polices/affichagePointsVie.ttf",30);
    if (pSdlJeu->police==NULL)
        pSdlJeu->police = TTF_OpenFont("../polices/affichagePointsVie.ttf",30);
    assert(pSdlJeu->police != NULL);

    pSdlJeu->grandePolice = NULL;
    pSdlJeu->grandePolice = TTF_OpenFont("polices/affichagePointsVie.ttf",40);
    if (pSdlJeu->grandePolice==NULL)
        pSdlJeu->grandePolice = TTF_OpenFont("../polices/affichagePointsVie.ttf",40);
    assert(pSdlJeu->grandePolice != NULL);

    /**
     @brief Ajout des images
     **/
    pSdlJeu->imageDeFond = SDL_charger_image("image/fond.png");
    if (pSdlJeu->imageDeFond==NULL)
        pSdlJeu->imageDeFond = SDL_charger_image("../image/fond.png");
    assert( pSdlJeu->imageDeFond!=NULL);

<<<<<<< .mine

    pSdlJeu->surfaceFuseeHaut = SDL_charger_image("image/fusee_haut.bmp");
=======
    pSdlJeu->surfaceFuseeHaut = SDL_charger_image("image/fuseeHaut.png");
>>>>>>> .r52
    if (pSdlJeu->surfaceFuseeHaut==NULL)
        pSdlJeu->surfaceFuseeHaut = SDL_charger_image("../image/fuseeHaut.png");
    assert( pSdlJeu->surfaceFuseeHaut!=NULL);


<<<<<<< .mine

    pSdlJeu->surfaceFuseeBas = SDL_charger_image("image/fusee_bas.bmp");
=======
    pSdlJeu->surfaceFuseeBas = SDL_charger_image("image/fuseeBas.png");
>>>>>>> .r52
    if (pSdlJeu->surfaceFuseeBas==NULL)
        pSdlJeu->surfaceFuseeBas = SDL_charger_image("../image/fuseeBas.png");
    assert( pSdlJeu->surfaceFuseeBas!=NULL);

<<<<<<< .mine
     pSdlJeu->surfaceBombe = SDL_charger_image("image/bombe.bmp");
=======
     pSdlJeu->surfaceBombe = SDL_charger_image("image/bombe.png");
>>>>>>> .r52
    if (pSdlJeu->surfaceBombe==NULL)
        pSdlJeu->surfaceBombe = SDL_charger_image("../image/bombe.png");
    assert( pSdlJeu->surfaceBombe!=NULL);

<<<<<<< .mine
     pSdlJeu->surfaceMissile = SDL_charger_image("image/missile.bmp");
=======
     pSdlJeu->surfaceMissile = SDL_charger_image("image/missile.png");
>>>>>>> .r52
    if (pSdlJeu->surfaceMissile==NULL)
        pSdlJeu->surfaceMissile= SDL_charger_image("../image/missile.png");
    assert( pSdlJeu->surfaceMissile!=NULL);

     pSdlJeu->surfaceBonusVie = SDL_charger_image("image/bonusVie.png");
    if (pSdlJeu->surfaceBonusVie==NULL)
        pSdlJeu->surfaceBonusVie= SDL_charger_image("../image/bonusVie.png");
    assert( pSdlJeu->surfaceBonusVie!=NULL);

<<<<<<< .mine
    /**
    @brief Initialisation de la position de l'image de fond
    **/
=======
    /* Initialisation des surfaces de police */
    pSdlJeu->pointsVieJoueur1=NULL;
    pSdlJeu->pointsVieJoueur2=NULL;

    /* Initialisation de la position de l'image de fond */
>>>>>>> .r52
    pSdlJeu->posXImageFond = 0;
    pSdlJeu->posYImageFond = -1400;

}



void sdljeuAff(sdlJeu *pSdlJeu)
{
    int i;
    Jeu *j;
    TableauDynamique *tab;
    Equipement *eq;
    Bonus *b;
    SDL_Surface* surfaceFinJeu = NULL; //Image de fin du jeu
    SDL_Surface* surfaceFinJeu2 = NULL;
    int finDuJeu;

<<<<<<< .mine
    j=&(pSdlJeu->jeu);
=======
    char *chainePointVieJoueur1 = malloc(4*sizeof(int));
    char *chainePointVieJoueur2 = malloc(4*sizeof(int));
    SDL_Color blanc = {250, 250, 250};

    j=&(pSdlJeu->jeu);       //j est un pointeur sur le jeu
    tab=getTableauDynamiqueTerrain(getTerrain(j));  //tab est un pointeur sur le tableau dynamique d'equipements
    b=getBonusVie(j);// b est un pointeur vers le bonus du jeu
>>>>>>> .r52

<<<<<<< .mine
    /**
    @brief j est un pointeur sur le jeu
    **/
    tab=getTableauDynamiqueTerrain(getTerrain(j));

    /**
    @brief tab est un pointeur sur le tableau dynamique d'equipement
    **/

=======
    /*On applique l'image de fond */
>>>>>>> .r52

    /**
    @brief on applique l'image de fond et les fusées
    **/
    SDL_appliquer_surface(  pSdlJeu->imageDeFond, pSdlJeu->surfaceEcran,pSdlJeu->posXImageFond,pSdlJeu->posYImageFond);


    /**
    @brief on parcourt le tableau d'equipements pour afficher les tirs en cours
    **/
    for (i=0;i<getTailleTabDyn(tab);i++)
    /**
    @brief i va de 0 à taille du tableau dynamique
    **/
    {
        eq=getIemeElementTabDyn(tab,i);

        /**
        @brief eq pointe vers l'equipement de la case i du tableau dynamique
        **/
        if(getidEquipement(eq)==10)
        {
            SDL_appliquer_surface(  pSdlJeu->surfaceBombe, pSdlJeu->surfaceEcran,getposXEquipement(eq),getposYEquipement(eq));
        }
        if(getidEquipement(eq)==20)
        {
            SDL_appliquer_surface(  pSdlJeu->surfaceMissile, pSdlJeu->surfaceEcran,getposXEquipement(eq),getposYEquipement(eq));
        }
    }

    /* On affiche les fusées */
    SDL_appliquer_surface(  pSdlJeu->surfaceFuseeHaut, pSdlJeu->surfaceEcran, getposXFusee(getFuseeHaut(&(pSdlJeu->jeu))), getposYFusee(getFuseeHaut(&(pSdlJeu->jeu))));
    SDL_appliquer_surface (pSdlJeu->surfaceFuseeBas, pSdlJeu->surfaceEcran,getposXFusee(getFuseeBas(&(pSdlJeu->jeu))),getposYFusee(getFuseeBas(&(pSdlJeu->jeu))));

    /*Affichage du bonus */
    if (getvisibiliteBonus(b)==1)  //Si le Bonus est en mode visible, on l'affiche
    {
        SDL_appliquer_surface(  pSdlJeu->surfaceBonusVie, pSdlJeu->surfaceEcran,getposXBonus(b),getposYBonus(b));
    }

    /* On convertit les points de vie en chaine de caractere */
    sprintf(chainePointVieJoueur1,"%d",getpointVieFusee(getFuseeHaut(j)));
    sprintf(chainePointVieJoueur2,"%d",getpointVieFusee(getFuseeBas(j)));

    /* On affiche le nombre de points de vie restants */
    pSdlJeu->pointsVieJoueur1 = TTF_RenderText_Solid(pSdlJeu->police,chainePointVieJoueur1,blanc);
    SDL_appliquer_surface(  pSdlJeu->pointsVieJoueur1, pSdlJeu->surfaceEcran,20,20);

    pSdlJeu->pointsVieJoueur2 = TTF_RenderText_Solid(pSdlJeu->police,chainePointVieJoueur2,blanc);
    SDL_appliquer_surface(  pSdlJeu->pointsVieJoueur2, pSdlJeu->surfaceEcran,700,20);


    /* On teste si le jeu n'est pas finis */
    finDuJeu = finJeu(j);

        if (finDuJeu!=0)
        {
            switch (finDuJeu)
            {
            case 1: //Le joueur 1 a gagne
            surfaceFinJeu = TTF_RenderText_Solid(pSdlJeu->grandePolice,"Le joueur 1 a gagne",blanc);
            SDL_appliquer_surface(  surfaceFinJeu, pSdlJeu->surfaceEcran,10,250);
            surfaceFinJeu2 = TTF_RenderText_Solid(pSdlJeu->police,"Appuyez sur escape pour quitter",blanc);
            SDL_appliquer_surface(  surfaceFinJeu2, pSdlJeu->surfaceEcran,10,350);
            break;

            case 2: //Le joueur 2 a gagne
            surfaceFinJeu = TTF_RenderText_Solid(pSdlJeu->grandePolice,"Le joueur 2 a gagne",blanc);
            SDL_appliquer_surface(  surfaceFinJeu, pSdlJeu->surfaceEcran,10,250);
            surfaceFinJeu2 = TTF_RenderText_Solid(pSdlJeu->police,"Appuyez sur escape pour quitter",blanc);
            SDL_appliquer_surface(  surfaceFinJeu2, pSdlJeu->surfaceEcran,10,350);
            break;
            }

        }
}


void sdljeuBoucle(sdlJeu *pSdlJeu)
{
<<<<<<< .mine

    /**
    @brief Definition des variables
    **/
=======
    /* ## Definition des variables ## */
>>>>>>> .r52
    Jeu *j;
    Bonus *b;

    SDL_Event event;
    int rafraichissement = 0;
	int continuer = 1;
	int continuerApresJeu = 1;
    int finDuJeu = 0;
    int deplacementBonus = 1; //Contient la valeur du deplacement du bonus
    int changementDeplacementBonus = 0;


    /**
    @brief Gestion des touches
    **/


    /**
    @brief Joueur 1  (en haut)
    **/
    int q = 0;
    int d = 0;
    int z = 0;
    int s = 0;
    int space = 0;


    /**
    @brief Joueur 2  (en bas)
    **/
    int left = 0;
    int right = 0;
    int up = 0;
    int down = 0;
    int p = 0;
<<<<<<< .mine

    /**
    @brief Mode deplacement complet
    **/
=======

    /* Mode deplacement complet */
>>>>>>> .r52
    int autoriseDeplacementComplet = 0;


    /**
    @brief Gestion du temps
    **/
    float horlogeCourante, horlogePrecedente;
    float horlogeTirCouranteJoueur1, horlogeTirPrecedenteJoueur1, horlogeTirCouranteJoueur2, horlogeTirPrecedenteJoueur2;
    float horlogeDeplacementTirPrecedente, horlogeDeplacementTirCourante;
    float horlogeBonusPrecedente, horlogeBonusCourante;
    float horlogeSuppressionBonusPrecedente, horlogeSuppressionBonusCourante;

<<<<<<< .mine

    /**
    @brief j est le pointeur sur la structure "jeu" de AffichageSDL
    **/
=======
    float intervalleJeu = 0.05f;
    float intervalleTir = 0.4f;
    float intervalleDeplacementTir = 0.005f;
    float intervalleBonus = 10.0f;
    float intervalleSupressionBonus = 4.0f;


    /* j est le pointeur sur la structure "jeu" de AffichageSDL */
>>>>>>> .r52
    j=&(pSdlJeu->jeu);
    b=getBonusVie(j);

    sdljeuAff(pSdlJeu);
	assert( SDL_Flip( pSdlJeu->surfaceEcran )!=-1 );

    /* Fonction permettant de repeter une touche si elle est appuyee longuement */
    SDL_EnableKeyRepeat(3,3);

    /* Initialisation des horloges */
    horlogePrecedente = (float)clock()/(float)CLOCKS_PER_SEC;
    horlogeTirPrecedenteJoueur1 = (float)clock()/(float)CLOCKS_PER_SEC;
    horlogeTirPrecedenteJoueur2 = (float)clock()/(float)CLOCKS_PER_SEC;
    horlogeDeplacementTirPrecedente = (float)clock()/(float)CLOCKS_PER_SEC;
    horlogeBonusPrecedente = (float)clock()/(float)CLOCKS_PER_SEC;
    horlogeSuppressionBonusPrecedente = (float)clock()/(float)CLOCKS_PER_SEC;

<<<<<<< .mine


    /**
    @brief Fonction permettant de repeter une touche si elle est appuyee longuement
    **/
    SDL_EnableKeyRepeat(3,3);

=======
>>>>>>> .r52

    /**
    @brief Debut de la boucle eventielle
    **/
	while ( continuer == 1 )
	{
	    rafraichissement = 0;

<<<<<<< .mine

	   /**
       @brief Récupère l'horloge actuelle et la convertit en secondes
       **/
=======
        /* Récupère l'horloge actuelle et la convertit en secondes */
>>>>>>> .r52
       horlogeCourante = (float)clock()/(float)CLOCKS_PER_SEC;
       horlogeTirCouranteJoueur1 = (float)clock()/(float)CLOCKS_PER_SEC;
       horlogeTirCouranteJoueur2 = (float)clock()/(float)CLOCKS_PER_SEC;
       horlogeDeplacementTirCourante = (float)clock()/(float)CLOCKS_PER_SEC;
       horlogeBonusCourante = (float)clock()/(float)CLOCKS_PER_SEC;
       horlogeSuppressionBonusCourante = (float)clock()/(float)CLOCKS_PER_SEC;

<<<<<<< .mine
        /**
       @brief Deplacement des equipements
       **/
=======

        //Deplacement des equipements
>>>>>>> .r52
        if (horlogeDeplacementTirCourante-horlogeDeplacementTirPrecedente>=intervalleDeplacementTir)
        {
            gestionDeplacementEquipements(j);
            gestionCollisionEquipements(j);
            if (getvisibiliteBonus(b)==1)
            {
               changementDeplacementBonus = deplacerBonus(b, deplacementBonus);

               if (changementDeplacementBonus==-1) //On change pour aller vers la gauche
                {deplacementBonus=-1;}
                else
                {
                    if (changementDeplacementBonus==1)  //On change pour aller vers la droite
                        {deplacementBonus=1;}
                }
            }
            horlogeDeplacementTirPrecedente=horlogeDeplacementTirCourante;
        }




        //Gestion des Bonus
        if (horlogeBonusCourante-horlogeBonusPrecedente>=intervalleBonus) //Temps avant que le bonus ne soit crée
        {
            setvisibiliteBonus(b,1);  //On crée un bonus
            intervalleBonus=10+rand()%10;
            horlogeBonusPrecedente=horlogeBonusCourante;
            horlogeSuppressionBonusPrecedente=horlogeBonusCourante;
        }


        if (horlogeSuppressionBonusCourante-horlogeSuppressionBonusPrecedente>=intervalleSupressionBonus)// Temps avant que le bonus soit supprimé
        {
            setvisibiliteBonus(b,0); // On supprime le bonus
        }


        if (horlogeCourante-horlogePrecedente>=intervalleJeu)
        {
                if (pSdlJeu->posYImageFond>=-100)
                {
                    pSdlJeu->posYImageFond=-1400;  //On reinitialise la position de l'image de fond
                }
                pSdlJeu->posYImageFond=pSdlJeu->posYImageFond+1;
                horlogePrecedente = horlogeCourante;
                sdljeuAff(pSdlJeu);
                SDL_Flip( pSdlJeu->surfaceEcran );
        }

		while ( SDL_PollEvent( &event ) )
		{

            /**
            @brief Fermeture en cliquant sur la croix de fermeture
            **/
            if ( event.type == SDL_QUIT )
				continuer = 0;

<<<<<<< .mine
            /**
            @brief Rappel des touches du jeu
            **/

            /* touches pour le jeu:

            #joueur 1#
            q: gauche  -> case 'q'
            d: droite  -> case 'd'

            #joueur 2#
            l (fleche de gauche): gauche   -> case 'l'
            r (fleche de droite): droite   -> case 'r'
            */


=======
>>>>>>> .r52
              /**
               @brief Recuperation de toutes les touches appuyees, On recupere les touches et on stocke si elles sont appuyees dans un booleen
               **/
			if ( event.type == SDL_KEYDOWN )
			{
                 /**
                 @brief Commandes joueur 1
                **/
				 if(event.key.keysym.sym == SDLK_q)
                    {
                        q = 1;
                    }
                if(event.key.keysym.sym == SDLK_d)
                    {
                        d = 1;
                    }
				 if(event.key.keysym.sym == SDLK_z)
                    {
                        z = 1;
                    }
                if(event.key.keysym.sym == SDLK_s)
                    {
                        s = 1;
                    }
                if(event.key.keysym.sym == SDLK_SPACE)
                    {
                        space = 1;
                    }
			    /**
                 @brief Commandes joueur 2
                **/
                 if(event.key.keysym.sym == SDLK_LEFT)
                    {
                        left = 1;
                    }
                if(event.key.keysym.sym == SDLK_RIGHT)
                    {
                        right = 1;
                    }
                if(event.key.keysym.sym == SDLK_UP)
                    {
                        up = 1;
                    }
                if(event.key.keysym.sym == SDLK_DOWN)
                    {
                        down = 1;
                    }
                if(event.key.keysym.sym == SDLK_p)
                    {
                        p = 1;
                    }

<<<<<<< .mine
                /**
                 @brief autres Commandes
                **/
=======
                //Autres commandes
>>>>>>> .r52
                if(event.key.keysym.sym == SDLK_b)
                    {
                        autoriseDeplacementComplet = 1;
                    }
                if (event.key.keysym.sym == SDLK_ESCAPE)
                    {
                        continuer = 0;
                    }
			}

			if ( event.type == SDL_KEYUP )
			{
			     /**
                 @brief Commandes joueur 1
                  **/
				 if(event.key.keysym.sym == SDLK_q)
                    {
                        q = 0;
                    }
                if(event.key.keysym.sym == SDLK_d)
                    {
                        d = 0;
                    }
                if(event.key.keysym.sym == SDLK_z)
                    {
                        z = 0;
                    }
                if(event.key.keysym.sym == SDLK_s)
                    {
                        s = 0;
                    }
                 if(event.key.keysym.sym == SDLK_SPACE)
                    {
                        space = 0;
                    }

			    /**
                 @brief Commandes joueur 2
                **/
				 if(event.key.keysym.sym == SDLK_LEFT)
                    {
                        left = 0;
                    }
                if(event.key.keysym.sym == SDLK_RIGHT)
                    {
                        right = 0;
                    }
                if(event.key.keysym.sym == SDLK_UP)
                    {
                        up = 0;
                    }
                if(event.key.keysym.sym == SDLK_DOWN)
                    {
                        down = 0;
                    }
                if(event.key.keysym.sym == SDLK_p)
                    {
                        p = 0;
                    }
			}

                /**
                 @brief Traitement des actions en fonction des touches appuyees
                **/

                /**
                 @brief Commandes joueur 1
                **/
                if (q == 1)
                    {
                        actionsClavier(j, 'q');
                        rafraichissement = 1;
                    }
				if (d == 1)
                    {
                        actionsClavier(j, 'd');
                        rafraichissement = 1;
                    }
                if (z == 1)
                    {
                        if (autoriseDeplacementComplet == 1)
                       {
                            actionsClavier(j, 'z');
                            rafraichissement = 1;
                       }
                    }
				if (s == 1)
                    {
                        if (autoriseDeplacementComplet == 1)
                       {
                            actionsClavier(j, 's');
                            rafraichissement = 1;
                       }
                    }
                if (space==1)
                {
                    if (horlogeTirCouranteJoueur1-horlogeTirPrecedenteJoueur1>=intervalleTir)
                        {
                            actionsClavier(j,'c');
                            rafraichissement = 1;
                            horlogeTirPrecedenteJoueur1=horlogeTirCouranteJoueur1;
                        }
                }

                /**
                 @brief Commandes joueur 2
                **/
				if (left == 1)
                    {
                        actionsClavier(j, 'l');
                        rafraichissement = 1;
                    }
				if (right == 1)
                    {
                        actionsClavier(j, 'r');
                        rafraichissement = 1;
                    }
                if (up == 1)
                    {
                    if (autoriseDeplacementComplet == 1)
                        {
                            actionsClavier(j, 'u');
                            rafraichissement = 1;
                        }
                    }
				if (down == 1)
                    {
                     if (autoriseDeplacementComplet == 1)
                       {
                            actionsClavier(j, 'n');
                            rafraichissement = 1;
                       }
                    }
                if (p == 1)
                {
                    if (horlogeTirCouranteJoueur2-horlogeTirPrecedenteJoueur2>=intervalleTir)
                        {
                            actionsClavier(j,'p');
                            rafraichissement = 1;
                            horlogeTirPrecedenteJoueur2=horlogeTirCouranteJoueur2;
                        }
                }

        /* Affichage du jeu et permutation du buffer */

        if (rafraichissement == 1)
            {
                sdljeuAff(pSdlJeu);
                SDL_Flip( pSdlJeu->surfaceEcran );
            }

        finDuJeu=finJeu(j);

        if((finDuJeu==1)||(finDuJeu==2))
        {
            sdljeuAff(pSdlJeu);
            SDL_Flip( pSdlJeu->surfaceEcran );
            continuer=0;
        }
        }
	}
	/* ## Fin de la boucle eventielle ## */


    if((finDuJeu==1)||(finDuJeu==2))
    {
    while(continuerApresJeu)
    {
        while ( SDL_PollEvent( &event ) )
		{

            /* Fermeture en cliquant sur la croix de fermeture */
            if ( event.type == SDL_QUIT )
				continuerApresJeu = 0;

            if ( event.type == SDL_KEYDOWN )
				{
                if (event.key.keysym.sym == SDLK_ESCAPE)
                    {
                        continuerApresJeu = 0;
                    }
				}
        }
	}
    }
}


void sdljeuBoucle1Joueur(sdlJeu *pSdlJeu)
{

    /* ## Definition des variables ## */
    Jeu *j;
    Bonus *b;
	SDL_Event event;
	int continuer = 1;
	int continuerApresJeu = 1;
    int finDuJeu = 0;
    int rafraichissement=0;
    float aleatoireDecisionIA;

    int deplacementBonus = 1; //Contient la valeur du deplacement du bonus
    int changementDeplacementBonus = 0;

    /*Gestion des touches */

    //Joueur 1  (en haut)
    int q = 0;
    int d = 0;
    int z = 0;
    int s = 0;
    int space = 0;

    /* Mode deplacement complet */
    int autoriseDeplacementComplet = 0;

    /* Gestion du temps */
    float horlogeCourante, horlogePrecedente;
    float horlogeTirCouranteJoueur1, horlogeTirPrecedenteJoueur1;
    float horlogeDeplacementTirPrecedente, horlogeDeplacementTirCourante;
    float horlogeDecisionIAPrecedente, horlogeDecisionIACourante;
    float horlogeDeplacementIAPrecedente, horlogeDeplacementIACourante;
    float horlogeTirIAPrecedente, horlogeTirIACourante;
    float horlogeBonusPrecedente, horlogeBonusCourante;
    float horlogeSuppressionBonusPrecedente, horlogeSuppressionBonusCourante;

    float intervalleJeu = 0.05f;
    float intervalleTir = 0.4f;
    float intervalleDeplacementTir = 0.005f;
    float intervalleDecisionIA = 0.5f;
    float intervalleDeplacementIA = 0.003f;
    float intervalleTirIA = 0.9f;
    float intervalleBonus = 10.0f;
    float intervalleSupressionBonus = 4.0f;

    /* j est le pointeur sur la structure "jeu" de AffichageSDL */
    j=&(pSdlJeu->jeu);
    b=getBonusVie(j);
    sdljeuAff(pSdlJeu);
	assert( SDL_Flip( pSdlJeu->surfaceEcran )!=-1 );

    horlogePrecedente = (float)clock()/(float)CLOCKS_PER_SEC;
    horlogeTirPrecedenteJoueur1 = (float)clock()/(float)CLOCKS_PER_SEC;
    horlogeDeplacementTirPrecedente = (float)clock()/(float)CLOCKS_PER_SEC;
    horlogeDecisionIAPrecedente = (float)clock()/(float)CLOCKS_PER_SEC;
    horlogeDeplacementIAPrecedente = (float)clock()/(float)CLOCKS_PER_SEC;
    horlogeTirIAPrecedente = (float)clock()/(float)CLOCKS_PER_SEC;
    horlogeBonusPrecedente = (float)clock()/(float)CLOCKS_PER_SEC;
    horlogeSuppressionBonusPrecedente = (float)clock()/(float)CLOCKS_PER_SEC;

    /* Fonction permettant de repeter une touche si elle est appuyee longuement */
    SDL_EnableKeyRepeat(3,3);

    /* ## Debut de la boucle eventielle ## */
	while ( continuer == 1 )
	{
	    rafraichissement = 0;

	     /* Récupère l'horloge actuelle et la convertit en secondes */
       horlogeCourante = (float)clock()/(float)CLOCKS_PER_SEC;
       horlogeTirCouranteJoueur1 = (float)clock()/(float)CLOCKS_PER_SEC;
       horlogeDeplacementTirCourante = (float)clock()/(float)CLOCKS_PER_SEC;
       horlogeDecisionIACourante = (float)clock()/(float)CLOCKS_PER_SEC;
       horlogeDeplacementIACourante = (float)clock()/(float)CLOCKS_PER_SEC;
       horlogeTirIACourante = (float)clock()/(float)CLOCKS_PER_SEC;
       horlogeBonusCourante = (float)clock()/(float)CLOCKS_PER_SEC;
       horlogeSuppressionBonusCourante = (float)clock()/(float)CLOCKS_PER_SEC;

        /* ## Gestion de l'IA ## */


        //Deplacement

        if(horlogeDecisionIACourante-horlogeDecisionIAPrecedente>=intervalleDecisionIA)
        {
            changementDecisionIA(j);
            horlogeDecisionIAPrecedente=horlogeDecisionIACourante;
            aleatoireDecisionIA=(rand()%10)/10;
            intervalleDecisionIA=0.2f+aleatoireDecisionIA;
            rafraichissement = 1;
        }

        //On récupère la décision de l'IA contenue dans le jeu

        if (horlogeDeplacementIACourante-horlogeDeplacementIAPrecedente>=intervalleDeplacementIA)
        {
        switch (getDecisionIA(j))
        {
            case 10:
            actionsClavier(j,'r'); //On déplace à droite
            break;

            case -10:
            actionsClavier(j,'l'); //On déplace à gauche
            break;

            case 00:
            resterSurPlace(getFuseeHaut(j)); //On reste sur place

            default:
            break;
        }
        horlogeDeplacementIAPrecedente=horlogeDeplacementIACourante;
        rafraichissement=1;
        }

        //Tir
         if (horlogeTirIACourante-horlogeTirIAPrecedente>=intervalleTirIA)
            {
                tirIA(j);
                horlogeTirIAPrecedente=horlogeTirIACourante;
                rafraichissement = 1;
            }


        /* ## Gestion du jeu ## */
        //Deplacement des equipements
        if (horlogeDeplacementTirCourante-horlogeDeplacementTirPrecedente>=intervalleDeplacementTir)
        {
            gestionDeplacementEquipements(j);
            gestionCollisionEquipements(j);
             if (getvisibiliteBonus(b)==1)
            {
               changementDeplacementBonus = deplacerBonus(b, deplacementBonus);

               if (changementDeplacementBonus==-1) //On change pour aller vers la gauche
                {deplacementBonus=-1;}
                else
                {
                    if (changementDeplacementBonus==1)  //On change pour aller vers la droite
                        {deplacementBonus=1;}
                }
            }
            horlogeDeplacementTirPrecedente=horlogeDeplacementTirCourante;
        }


         //Gestion des Bonus
        if (horlogeBonusCourante-horlogeBonusPrecedente>=intervalleBonus) //Temps avant que le bonus ne soit crée
        {
            setvisibiliteBonus(b,1);  //On crée un bonus
            intervalleBonus=10+rand()%10;
            horlogeBonusPrecedente=horlogeBonusCourante;
            horlogeSuppressionBonusPrecedente=horlogeBonusCourante;
        }

        if (horlogeSuppressionBonusCourante-horlogeSuppressionBonusPrecedente>=intervalleSupressionBonus)// Temps avant que le bonus soit supprimé
        {
            setvisibiliteBonus(b,0); // On supprime le bonus
        }

        //Gestion du décors
        if (horlogeCourante-horlogePrecedente>=intervalleJeu)
        {
                if (pSdlJeu->posYImageFond>=-100)
                {
                    pSdlJeu->posYImageFond=-1400;  //On reinitialise la position de l'image de fond
                }
                pSdlJeu->posYImageFond=pSdlJeu->posYImageFond+1;
                horlogePrecedente = horlogeCourante;
                sdljeuAff(pSdlJeu);
                SDL_Flip( pSdlJeu->surfaceEcran );
        }

        /* ## Gestion des événements ## */
		while ( SDL_PollEvent( &event ) )
		{

            /* Fermeture en cliquant sur la croix de fermeture */
            if ( event.type == SDL_QUIT )
				continuer = 0;

            /* ## Recuperation de toutes les touches appuyees ## */
            /* On recupere les touches et on stocke si elles sont appuyees dans un booleen */
			if ( event.type == SDL_KEYDOWN )
			{
                //Commandes joueur 1
				 if(event.key.keysym.sym == SDLK_q)
                    {
                        q = 1;
                    }
                if(event.key.keysym.sym == SDLK_d)
                    {
                        d = 1;
                    }
				 if(event.key.keysym.sym == SDLK_z)
                    {
                        z = 1;
                    }
                if(event.key.keysym.sym == SDLK_s)
                    {
                        s = 1;
                    }
                if(event.key.keysym.sym == SDLK_SPACE)
                    {
                        space = 1;
                    }

                //Autres commandes
                if(event.key.keysym.sym == SDLK_b)
                    {
                        autoriseDeplacementComplet = 1;
                    }
                if (event.key.keysym.sym == SDLK_ESCAPE)
                    {
                        continuer = 0;
                    }
			}

              /**
                @brief Affichage du jeu et permutation du buffer
               **/
			if ( event.type == SDL_KEYUP )
			{
			    //Commandes joueur 1
				 if(event.key.keysym.sym == SDLK_q)
                    {
                        q = 0;
                    }
                if(event.key.keysym.sym == SDLK_d)
                    {
                        d = 0;
                    }
                if(event.key.keysym.sym == SDLK_z)
                    {
                        z = 0;
                    }
                if(event.key.keysym.sym == SDLK_s)
                    {
                        s = 0;
                    }
                 if(event.key.keysym.sym == SDLK_SPACE)
                    {
                        space = 0;
                    }
			}

            /* ## Traitement des actions en fonction des touches appuyees ## */

                //Commandes joueur 1
                if (q == 1)
                    {
                        actionsClavier(j, 'q');
                        rafraichissement = 1;
                    }
				if (d == 1)
                    {
                        actionsClavier(j, 'd');
                        rafraichissement = 1;
                    }
                if (z == 1)
                    {
                        if (autoriseDeplacementComplet == 1)
                       {
                            actionsClavier(j, 'z');
                            rafraichissement = 1;
                       }
                    }
				if (s == 1)
                    {
                        if (autoriseDeplacementComplet == 1)
                       {
                            actionsClavier(j, 's');
                            rafraichissement = 1;
                       }
                    }
                if (space==1)
                {
                    if (horlogeTirCouranteJoueur1-horlogeTirPrecedenteJoueur1>=intervalleTir)
                        {
                            actionsClavier(j,'c');
                            horlogeTirPrecedenteJoueur1=horlogeTirCouranteJoueur1;
                            rafraichissement = 1;

                        }
                }

        /* Affichage du jeu et permutation du buffer */
        if (rafraichissement==1)
        {
            sdljeuAff(pSdlJeu);
            SDL_Flip( pSdlJeu->surfaceEcran );
        }

        finDuJeu=finJeu(j);

        if((finDuJeu==1)||(finDuJeu==2))
        {
            sdljeuAff(pSdlJeu);
            SDL_Flip( pSdlJeu->surfaceEcran );
            continuer=0;
        }
	}

    /**
    @brief Fin de la boucle eventielle
    **/

	}

	 if((finDuJeu==1)||(finDuJeu==2))
    {
    while(continuerApresJeu)
    {
        while ( SDL_PollEvent( &event ) )
		{

            /* Fermeture en cliquant sur la croix de fermeture */
            if ( event.type == SDL_QUIT )
				continuerApresJeu = 0;

            if ( event.type == SDL_KEYDOWN )
				{
                if (event.key.keysym.sym == SDLK_ESCAPE)
                    {
                        continuerApresJeu = 0;
                    }
				}
        }
	}
    }
}




void SDL_appliquer_surface( SDL_Surface* source, SDL_Surface* destination, int x, int y )
{
    SDL_Rect offset;

    offset.x = x;
    offset.y = y;

   SDL_BlitSurface( source, NULL, destination, &offset );
}

 /**
  @brief Preconditions : nomFic nom d'fichier BMP existant; Postcondition : retourne un SDL_Surface avec l'image optimisee
  **/
SDL_Surface *SDL_charger_image(const char* nomFic )
{
    SDL_Surface* imageChargee = NULL;
    SDL_Surface* imageOptimisee = NULL;

    imageChargee = IMG_Load( nomFic );

    if ( imageChargee != NULL )
    {
        imageOptimisee = SDL_DisplayFormat( imageChargee );
        //SDL_SetColorKey(imageOptimisee, SDL_SRCCOLORKEY, SDL_MapRGB(imageOptimisee->format, 0, 255, 0));
        SDL_FreeSurface( imageChargee );
    }

    return imageOptimisee;
}

void sdlLibere(sdlJeu * pSdlJeu)
{
    SDL_FreeSurface( pSdlJeu->surfaceFuseeHaut );
    SDL_FreeSurface( pSdlJeu->surfaceFuseeBas );
    SDL_FreeSurface( pSdlJeu->surfaceBombe);
    SDL_FreeSurface( pSdlJeu->surfaceMissile);
    SDL_FreeSurface( pSdlJeu->imageDeFond );
    SDL_FreeSurface( pSdlJeu->surfaceEcran );
    SDL_FreeSurface( pSdlJeu->surfaceBonusVie);
    SDL_FreeSurface( pSdlJeu->pointsVieJoueur1 );
    SDL_FreeSurface( pSdlJeu->pointsVieJoueur2 );

    SDL_Quit();
    TTF_CloseFont(pSdlJeu->police);
    TTF_CloseFont(pSdlJeu->grandePolice);
    TTF_Quit();
    libereJeu(&(pSdlJeu->jeu));

}
 /**
 @brief Test de non-régression
 **/
 /*
void testRegressionAffichageSDL()
{

    printf("###  Test du module affichageSDL ### \n");

	sdlJeu pSdlJeu;

	 @brief test des fonctions d'initialisation
	     sdljeuInit(&pSdlJeu);
    printf("-- Fonctions d'initialisation testees avec succes -- \n");


    @brief test de la fonction d'affichage

     sdljeuAff(&pSdlJeu);
	printf("-- Fonctions d'affichage testees avec succes -- \n");


	@brief test de la fonction de libération

    sdlLibere(&pSdlJeu);

	printf("-- Fonction de liberation testee avec succes  -- \n");

    printf("***  Test du module AffichageSDL realise avec succes *** \n\n\n");

}
*/







